////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  aecglobalelements.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AECGLOBALELEMENTS_H
#define AECGLOBALELEMENTS_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "globalelements.h"

#define AECGLOBALELEMENTS_NAMESPACE_BEGIN namespace aecglobalelements {
#define AECGLOBALELEMENTS_NAMESPACE_END }

AECGLOBALELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LuxLumaTargetZoneDataType
/// Comments:       AEC Tuning: Key metering structures
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LuxLumaTargetZoneDataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lumaTarget
    ///
    /// Tuning Level:  often_tune
    /// Description:   Luma target value for each zone with 8 bit range.
    /// Range:         [0,255]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT lumaTarget;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TriggerPointType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct TriggerPointType
{
    FLOAT start;
    FLOAT end;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LuxLumaTargetZoneType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LuxLumaTargetZoneType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneTrigger
    ///
    /// Description:   lux level start and end values that define trigger region
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    TriggerPointType          zoneTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneData
    ///
    /// Description:   Triggered data: Luma targets that will be adjusted based on lux level
    /// Comments:       AEC Tuning: Key metering structures
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    LuxLumaTargetZoneDataType zoneData;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LuxLumaTargetType
///
/// Description:   Luma target tuning structure, which is shared between normal and flash use case.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LuxLumaTargetType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luxLumaTargetZone - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                 luxLumaTargetZoneCount;
    UINT32                 luxLumaTargetZoneID;
    LuxLumaTargetZoneType* luxLumaTargetZone;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// StartEndType
/// Comments:       Base Type Tuning Definition
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct StartEndType
{
    FLOAT start;
    FLOAT end;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LuxFaceWeightZoneDataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LuxFaceWeightZoneDataType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LuxFaceWeight
    ///
    /// Tuning Level:  rear_tune
    /// Description:   Min and Max face luma weight wrt face size.
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    StartEndType LuxFaceWeight;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LuxFaceWeightZoneType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LuxFaceWeightZoneType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneTrigger
    ///
    /// Description:   lux level start and end values that define trigger region
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    TriggerPointType          zoneTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// zoneData
    ///
    /// Description:   Triggered data: face weight that will be adjusted based on lux level
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    LuxFaceWeightZoneDataType zoneData;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LuxFaceWeightType
///
/// Description:   Face weight tuning structure, which is shared between normal and flash use case.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LuxFaceWeightType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LuxFaceWeightZone - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                 LuxFaceWeightZoneCount;
    UINT32                 LuxFaceWeightZoneID;
    LuxFaceWeightZoneType* LuxFaceWeightZone;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECExpIncPrioType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class AECExpIncPrioType
{
    AECExpIncGain    = 0,
    AECExpIncExpTime = 1,
    AECExpIncPrioMax = 2
};
typedef INT32 ExposureTableIDType;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECBayerGridSubsmplType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class AECBayerGridSubsmplType
{
    Off = 0,
    SW2 = 1,
    SW4 = 2,
    Max = 3
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECColorChannelType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class AECColorChannelType
{
    AECColorChannelR   = 0,
    AECColorChannelG   = 1,
    AECColorChannelB   = 2,
    AECColorChannelMax = 3
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECConvAlgoType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class AECConvAlgoType
{
    AECConvSlowConv = 0,
    AECConvFastConv = 1,
    AECConvMaxConv  = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECAntibandingVsFPSMethod
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class AECAntibandingVsFPSMethod
{
    LegacyAllowFPSToDrop = 0,
    StrictlyEnforceFPS   = 1,
    MaximizeExposureTime = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ConvFrameSkipType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ConvFrameSkipType
{
    SmoothNoSkip      = 0,
    SkipOne           = 1,
    SkipSystemLatency = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FirstFrameBiasType
///
/// Description:   Heuristics to speed up convergence in first frame
/// Comments:       Rapid Startup is used by both Startup and Flash algorithms
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FirstFrameBiasType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableStartUpBias
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Enable biasing to converge faster in the first frame in the presence of saturated regions
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL         enableStartUpBias;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// firstFrameStepSizeDarkMax
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   When converging from dark to bright: maximum absolute exposure index step size for first frame
    /// Range:         [0,200]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        firstFrameStepSizeDarkMax;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepSizeBrightAdjRange
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   When converging from bright to dark: Exposure index step size range within which a factor will be applied
    ///                to converge faster in the first frame
    /// Range:         [20,80]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    StartEndType stepSizeBrightAdjRange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxAdjFactor
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Max factor to boost exposure adjustment in the first frame
    /// Range:         [1.5,3.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        maxAdjFactor;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// RapidConvType
///
/// Description:   Tuning settings for initial convergence algorithms: FastAEC and AggressiveAEC
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct RapidConvType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// firstFrameBias
    ///
    /// Description:   Heuristics to speed up convergence in first frame
    /// Comments:       Rapid Startup is used by both Startup and Flash algorithms
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FirstFrameBiasType firstFrameBias;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// startExpIndex
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Preferred initial exposure index
    /// Range:         [0,500]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT              startExpIndex;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolMultUnitStepSize
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Tolerance expressed as a multiple of unitStepSize
    /// Range:         [2,6]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32              tolMultUnitStepSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameSkipInit
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Initial frame skip
    /// Range:         [0,4]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32              frameSkipInit;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameSkip
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   How many frames to skip between two adjustments. Depends on sensor sync
    /// Range:         [2,3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32              frameSkip;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minSettledCount
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   How many frames without any adjustments before declaring the algorithm is settled
    /// Range:         [3,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32              minSettledCount;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxFrameConvTimeOut
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Maximum duration of convergence, in frames
    /// Range:         [10,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32              maxFrameConvTimeOut;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ModuleVersionType
///
/// Description:   define major, minor, incremental revision -
/// Comments:       Global Tuning Definition
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ModuleVersionType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// major_revision
    ///
    /// Description:   Major revision number
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 major_revision;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minor_revision
    ///
    /// Description:   Minor revision number
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 minor_revision;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// incr_revision
    ///
    /// Description:   Incremental revision number
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 incr_revision;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// aecglobalelementsClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class aecglobalelementsClass
{
public:

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LuxLumaTargetZoneDataType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLuxLumaTargetZoneDataType(
        ParameterFileSymbolTableEntry* entry,
        LuxLumaTargetZoneDataType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load TriggerPointType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadTriggerPointType(
        ParameterFileSymbolTableEntry* entry,
        TriggerPointType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LuxLumaTargetZoneType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLuxLumaTargetZoneType(
        ParameterFileSymbolTableEntry* entry,
        LuxLumaTargetZoneType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LuxLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLuxLumaTargetType(
        ParameterFileSymbolTableEntry* entry,
        LuxLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load StartEndType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadStartEndType(
        ParameterFileSymbolTableEntry* entry,
        StartEndType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LuxFaceWeightZoneDataType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLuxFaceWeightZoneDataType(
        ParameterFileSymbolTableEntry* entry,
        LuxFaceWeightZoneDataType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LuxFaceWeightZoneType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLuxFaceWeightZoneType(
        ParameterFileSymbolTableEntry* entry,
        LuxFaceWeightZoneType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LuxFaceWeightType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLuxFaceWeightType(
        ParameterFileSymbolTableEntry* entry,
        LuxFaceWeightType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load FirstFrameBiasType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadFirstFrameBiasType(
        ParameterFileSymbolTableEntry* entry,
        FirstFrameBiasType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load RapidConvType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadRapidConvType(
        ParameterFileSymbolTableEntry* entry,
        RapidConvType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ModuleVersionType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadModuleVersionType(
        ParameterFileSymbolTableEntry* entry,
        ModuleVersionType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload LuxLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadLuxLumaTargetType(
        LuxLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload LuxFaceWeightType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadLuxFaceWeightType(
        LuxFaceWeightType* structure);

}; // End class aecglobalelementsClass

AECGLOBALELEMENTS_NAMESPACE_END
#endif // AECGLOBALELEMENTS_H

